home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 23 / CU Amiga - Super CD-ROM 23 (June 1998).iso / CUCD / Games / ADoomPPC / src / r_main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-19  |  16.1 KB  |  902 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Rendering main loop and setup functions,
  21. //     utility functions (BSP, geometry, trigonometry).
  22. //    See tables.c, too.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. static const char rcsid[] = "$Id: r_main.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
  28.  
  29.  
  30.  
  31. #include <stdlib.h>
  32. /* #include <math.h> */
  33.  
  34.  
  35. #include "doomdef.h"
  36. #include "doomstat.h"
  37. #include "d_net.h"
  38.  
  39. #include "m_bbox.h"
  40.  
  41. #include "r_local.h"
  42. #include "r_sky.h"
  43. #include "st_stuff.h"
  44.  
  45. extern int cpu_type;
  46.  
  47.  
  48.  
  49. // Fineangles in the SCREENWIDTH wide window.
  50. #define FIELDOFVIEW        2048    
  51.  
  52.  
  53.  
  54. int            viewangleoffset;
  55.  
  56. // increment every time a check is made
  57. int            validcount = 1;        
  58.  
  59.  
  60. lighttable_t*        fixedcolormap;
  61. extern lighttable_t**    walllights;
  62.  
  63. int            centerx;
  64. int            centery;
  65.  
  66. fixed_t            centerxfrac;
  67. fixed_t            centeryfrac;
  68. fixed_t            projection;
  69.  
  70. // just for profiling purposes
  71. int            framecount;    
  72.  
  73. int            sscount;
  74. int            linecount;
  75. int            loopcount;
  76.  
  77. fixed_t            viewx;
  78. fixed_t            viewy;
  79. fixed_t            viewz;
  80.  
  81. angle_t            viewangle;
  82.  
  83. fixed_t            viewcos;
  84. fixed_t            viewsin;
  85.  
  86. player_t*        viewplayer;
  87.  
  88. // 0 = high, 1 = low
  89. int            detailshift;    
  90.  
  91. //
  92. // precalculated math tables
  93. //
  94. angle_t            clipangle;
  95.  
  96. // The viewangletox[viewangle + FINEANGLES/4] lookup
  97. // maps the visible view angles to screen X coordinates,
  98. // flattening the arc to a flat projection plane.
  99. // There will be many angles mapped to the same X. 
  100. FAR int            viewangletox[FINEANGLES/2];
  101.  
  102. // The xtoviewangleangle[] table maps a screen pixel
  103. // to the lowest viewangle that maps back to x ranges
  104. // from clipangle to -clipangle.
  105. //angle_t            xtoviewangle[SCREENWIDTH+1];
  106. angle_t            *xtoviewangle;
  107.  
  108.  
  109. // UNUSED.
  110. // The finetangentgent[angle+FINEANGLES/4] table
  111. // holds the fixed_t tangent values for view angles,
  112. // ranging from MININT to 0 to MAXINT.
  113. // fixed_t        finetangent[FINEANGLES/2];
  114.  
  115. // fixed_t        finesine[5*FINEANGLES/4];
  116. fixed_t*        finecosine = &finesine[FINEANGLES/4];
  117.  
  118.  
  119. FAR lighttable_t*    scalelight[LIGHTLEVELS][MAXLIGHTSCALE];
  120. lighttable_t*        scalelightfixed[MAXLIGHTSCALE];
  121. FAR lighttable_t*    zlight[LIGHTLEVELS][MAXLIGHTZ];
  122.  
  123. // bumped light from gun blasts
  124. int            extralight;            
  125.  
  126.  
  127.  
  128. void (*colfunc) (void);
  129. void (*basecolfunc) (void);
  130. void (*fuzzcolfunc) (void);
  131. void (*transcolfunc) (void);
  132. void (*spanfunc) (void);
  133.  
  134.  
  135.  
  136. //
  137. // R_AddPointToBox
  138. // Expand a given bbox
  139. // so that it encloses a given point.
  140. //
  141. void
  142. R_AddPointToBox
  143. ( int        x,
  144.   int        y,
  145.   fixed_t*    box )
  146. {
  147.     if (x< box[BOXLEFT])
  148.     box[BOXLEFT] = x;
  149.     if (x> box[BOXRIGHT])
  150.     box[BOXRIGHT] = x;
  151.     if (y< box[BOXBOTTOM])
  152.     box[BOXBOTTOM] = y;
  153.     if (y> box[BOXTOP])
  154.     box[BOXTOP] = y;
  155. }
  156.  
  157.  
  158. //
  159. // R_PointOnSide
  160. // Traverse BSP (sub) tree,
  161. //  check point against partition plane.
  162. // Returns side 0 (front) or 1 (back).
  163. //
  164. int
  165. R_PointOnSide
  166. ( fixed_t    x,
  167.   fixed_t    y,
  168.   node_t*    node )
  169. {
  170.     fixed_t    dx;
  171.     fixed_t    dy;
  172.     fixed_t    left;
  173.     fixed_t    right;
  174.     
  175.     if (!node->dx)
  176.     {
  177.     if (x <= node->x)
  178.         return node->dy > 0;
  179.     
  180.     return node->dy < 0;
  181.     }
  182.     if (!node->dy)
  183.     {
  184.     if (y <= node->y)
  185.         return node->dx < 0;
  186.     
  187.     return node->dx > 0;
  188.     }
  189.     
  190.     dx = (x - node->x);
  191.     dy = (y - node->y);
  192.     
  193.     // Try to quickly decide by looking at sign bits.
  194.     if ( (node->dy ^ node->dx ^ dx ^ dy)&0x80000000 )
  195.     {
  196.     if  ( (node->dy ^ dx) & 0x80000000 )
  197.     {
  198.         // (left is negative)
  199.         return 1;
  200.     }
  201.     return 0;
  202.     }
  203.  
  204.     left = FixedMul ( node->dy>>FRACBITS , dx );
  205.     right = FixedMul ( dy , node->dx>>FRACBITS );
  206.     
  207.     if (right < left)
  208.     {
  209.     // front side
  210.     return 0;
  211.     }
  212.     // back side
  213.     return 1;            
  214. }
  215.  
  216.  
  217. int
  218. R_PointOnSegSide
  219. ( fixed_t    x,
  220.   fixed_t    y,
  221.   seg_t*    line )
  222. {
  223.     fixed_t    lx;
  224.     fixed_t    ly;
  225.     fixed_t    ldx;
  226.     fixed_t    ldy;
  227.     fixed_t    dx;
  228.     fixed_t    dy;
  229.     fixed_t    left;
  230.     fixed_t    right;
  231.     
  232.     lx = line->v1->x;
  233.     ly = line->v1->y;
  234.     
  235.     ldx = line->v2->x - lx;
  236.     ldy = line->v2->y - ly;
  237.     
  238.     if (!ldx)
  239.     {
  240.     if (x <= lx)
  241.         return ldy > 0;
  242.     
  243.     return ldy < 0;
  244.     }
  245.     if (!ldy)
  246.     {
  247.     if (y <= ly)
  248.         return ldx < 0;
  249.     
  250.     return ldx > 0;
  251.     }
  252.     
  253.     dx = (x - lx);
  254.     dy = (y - ly);
  255.     
  256.     // Try to quickly decide by looking at sign bits.
  257.     if ( (ldy ^ ldx ^ dx ^ dy)&0x80000000 )
  258.     {
  259.     if  ( (ldy ^ dx) & 0x80000000 )
  260.     {
  261.         // (left is negative)
  262.         return 1;
  263.     }
  264.     return 0;
  265.     }
  266.  
  267.     left = FixedMul ( ldy>>FRACBITS , dx );
  268.     right = FixedMul ( dy , ldx>>FRACBITS );
  269.     
  270.     if (right < left)
  271.     {
  272.     // front side
  273.     return 0;
  274.     }
  275.     // back side
  276.     return 1;            
  277. }
  278.  
  279.  
  280. //
  281. // R_PointToAngle
  282. // To get a global angle from cartesian coordinates,
  283. //  the coordinates are flipped until they are in
  284. //  the first octant of the coordinate system, then
  285. //  the y (<=x) is scaled and divided by x to get a
  286. //  tangent (slope) value which is looked up in the
  287. //  tantoangle[] table.
  288. //
  289.  
  290. angle_t
  291. R_PointToAngle
  292. ( fixed_t    x,
  293.   fixed_t    y )
  294. {    
  295.     x -= viewx;
  296.     y -= viewy;
  297.     
  298.     if ( (!x) && (!y) )
  299.     return 0;
  300.  
  301.     if (x>= 0)
  302.     {
  303.     // x >=0
  304.     if (y>= 0)
  305.     {
  306.         // y>= 0
  307.  
  308.         if (x>y)
  309.         {
  310.         // octant 0
  311.         return tantoangle[ SlopeDiv(y,x)];
  312.         }
  313.         else
  314.         {
  315.         // octant 1
  316.         return ANG90-1-tantoangle[ SlopeDiv(x,y)];
  317.         }
  318.     }
  319.     else
  320.     {
  321.         // y<0
  322.         y = -y;
  323.  
  324.         if (x>y)
  325.         {
  326.         // octant 8
  327.         return -tantoangle[SlopeDiv(y,x)];
  328.         }
  329.         else
  330.         {
  331.         // octant 7
  332.         return ANG270+tantoangle[ SlopeDiv(x,y)];
  333.         }
  334.     }
  335.     }
  336.     else
  337.     {
  338.     // x<0
  339.     x = -x;
  340.  
  341.     if (y>= 0)
  342.     {
  343.         // y>= 0
  344.         if (x>y)
  345.         {
  346.         // octant 3
  347.         return ANG180-1-tantoangle[ SlopeDiv(y,x)];
  348.         }
  349.         else
  350.         {
  351.         // octant 2
  352.         return ANG90+ tantoangle[ SlopeDiv(x,y)];
  353.         }
  354.     }
  355.     else
  356.     {
  357.         // y<0
  358.         y = -y;
  359.  
  360.         if (x>y)
  361.         {
  362.         // octant 4
  363.         return ANG180+tantoangle[ SlopeDiv(y,x)];
  364.         }
  365.         else
  366.         {
  367.          // octant 5
  368.         return ANG270-1-tantoangle[ SlopeDiv(x,y)];
  369.         }
  370.     }
  371.     }
  372.     return 0;
  373. }
  374.  
  375.  
  376. angle_t
  377. R_PointToAngle2
  378. ( fixed_t    x1,
  379.   fixed_t    y1,
  380.   fixed_t    x2,
  381.   fixed_t    y2 )
  382. {    
  383.     viewx = x1;
  384.     viewy = y1;
  385.     
  386.     return R_PointToAngle (x2, y2);
  387. }
  388.  
  389.  
  390. fixed_t
  391. R_PointToDist
  392. ( fixed_t    x,
  393.   fixed_t    y )
  394. {
  395.     int        angle;
  396.     fixed_t    dx;
  397.     fixed_t    dy;
  398.     fixed_t    temp;
  399.     fixed_t    dist;
  400.     
  401.     dx = iabs(x - viewx);
  402.     dy = iabs(y - viewy);
  403.     
  404.     if (dy>dx)
  405.     {
  406.     temp = dx;
  407.     dx = dy;
  408.     dy = temp;
  409.     }
  410.     
  411.     angle = (tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90) >> ANGLETOFINESHIFT;
  412.  
  413.     // use as cosine
  414.     dist = FixedDiv (dx, finesine[angle] );    
  415.     
  416.     return dist;
  417. }
  418.  
  419.  
  420.  
  421. //
  422. // R_InitPointToAngle
  423. //
  424. void R_InitPointToAngle (void)
  425. {
  426.     // UNUSED - now getting from tables.c
  427. #if 0
  428.     int    i;
  429.     long    t;
  430.     float    f;
  431. //
  432. // slope (tangent) to angle lookup
  433. //
  434.     for (i=0 ; i<=SLOPERANGE ; i++)
  435.     {
  436.     f = atan( (float)i/SLOPERANGE )/(3.141592657*2);
  437.     t = 0xffffffff*f;
  438.     tantoangle[i] = t;
  439.     }
  440. #endif
  441. }
  442.  
  443.  
  444. //
  445. // R_ScaleFromGlobalAngle
  446. // Returns the texture mapping scale
  447. //  for the current line (horizontal span)
  448. //  at the given angle.
  449. // rw_distance must be calculated first.
  450. //
  451. fixed_t R_ScaleFromGlobalAngle (angle_t visangle)
  452. {
  453.     fixed_t        scale;
  454.     int            anglea;
  455.     int            angleb;
  456.     int            sinea;
  457.     int            sineb;
  458.     fixed_t        num;
  459.     int            den;
  460.  
  461.     // UNUSED
  462. #if 0
  463. {
  464.     fixed_t        dist;
  465.     fixed_t        z;
  466.     fixed_t        sinv;
  467.     fixed_t        cosv;
  468.     
  469.     sinv = finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT];    
  470.     dist = FixedDiv (rw_distance, sinv);
  471.     cosv = finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT];
  472.     z = iabs(FixedMul (dist, cosv));
  473.     scale = FixedDiv(projection, z);
  474.     return scale;
  475. }
  476. #endif
  477.  
  478.     anglea = ANG90 + (visangle-viewangle);
  479.     angleb = ANG90 + (visangle-rw_normalangle);
  480.  
  481.     // both sines are allways positive
  482.     sinea = finesine[anglea>>ANGLETOFINESHIFT];    
  483.     sineb = finesine[angleb>>ANGLETOFINESHIFT];
  484.     num = FixedMul(projection,sineb)<<detailshift;
  485.     den = FixedMul(rw_distance,sinea);
  486.  
  487.     if (den > num>>16)
  488.     {
  489.     scale = FixedDiv (num, den);
  490.  
  491.     if (scale > 64*FRACUNIT)
  492.         scale = 64*FRACUNIT;
  493.     else if (scale < 256)
  494.         scale = 256;
  495.     }
  496.     else
  497.     scale = 64*FRACUNIT;
  498.     
  499.     return scale;
  500. }
  501.  
  502.  
  503.  
  504. //
  505. // R_InitTables
  506. //
  507. void R_InitTables (void)
  508. {
  509.     // UNUSED: now getting from tables.c
  510. #if 0
  511.     int        i;
  512.     float    a;
  513.     float    fv;
  514.     int        t;
  515.     
  516.     // viewangle tangent table
  517.     for (i=0 ; i<FINEANGLES/2 ; i++)
  518.     {
  519.     a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES;
  520.     fv = FRACUNIT*tan (a);
  521.     t = fv;
  522.     finetangent[i] = t;
  523.     }
  524.     
  525.     // finesine table
  526.     for (i=0 ; i<5*FINEANGLES/4 ; i++)
  527.     {
  528.     // OPTIMIZE: mirror...
  529.     a = (i+0.5)*PI*2/FINEANGLES;
  530.     t = FRACUNIT*sin (a);
  531.     finesine[i] = t;
  532.     }
  533. #endif
  534.  
  535. }
  536.  
  537.  
  538.  
  539. //
  540. // R_InitTextureMapping
  541. //
  542. void R_InitTextureMapping (void)
  543. {
  544.     int            i;
  545.     int            x;
  546.     int            t;
  547.     fixed_t        focallength;
  548.  
  549.     // Use tangent table to generate viewangletox:
  550.     //  viewangletox will give the next greatest x
  551.     //  after the view angle.
  552.     //
  553.     // Calc focallength
  554.     //  so FIELDOFVIEW angles covers SCREENWIDTH.
  555.     focallength = FixedDiv (centerxfrac,
  556.                 finetangent[FINEANGLES/4+FIELDOFVIEW/2] );
  557.     
  558.     for (i=0 ; i<FINEANGLES/2 ; i++)
  559.     {
  560.     if (finetangent[i] > FRACUNIT*2)
  561.         t = -1;
  562.     else if (finetangent[i] < -FRACUNIT*2)
  563.         t = viewwidth+1;
  564.     else
  565.     {
  566.         t = FixedMul (finetangent[i], focallength);
  567.         t = (centerxfrac - t+FRACUNIT-1)>>FRACBITS;
  568.  
  569.         if (t < -1)
  570.         t = -1;
  571.         else if (t>viewwidth+1)
  572.         t = viewwidth+1;
  573.     }
  574.     viewangletox[i] = t;
  575.     }
  576.     
  577.     // Scan viewangletox[] to generate xtoviewangle[]:
  578.     //  xtoviewangle will give the smallest view angle
  579.     //  that maps to x.    
  580.     for (x=0;x<=viewwidth;x++)
  581.     {
  582.     i = 0;
  583.     while (viewangletox[i]>x)
  584.         i++;
  585.     xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
  586.     }
  587.     
  588.     // Take out the fencepost cases from viewangletox.
  589.     for (i=0 ; i<FINEANGLES/2 ; i++)
  590.     {
  591.     t = FixedMul (finetangent[i], focallength);
  592.     t = centerx - t;
  593.     
  594.     if (viewangletox[i] == -1)
  595.         viewangletox[i] = 0;
  596.     else if (viewangletox[i] == viewwidth+1)
  597.         viewangletox[i]  = viewwidth;
  598.     }
  599.     
  600.     clipangle = xtoviewangle[0];
  601. }
  602.  
  603.  
  604.  
  605. //
  606. // R_InitLightTables
  607. // Only inits the zlight table,
  608. //  because the scalelight table changes with view size.
  609. //
  610. #define DISTMAP        2
  611.  
  612. void R_InitLightTables (void)
  613. {
  614.     int        i;
  615.     int        j;
  616.     int        level;
  617.     int        startmap;     
  618.     int        scale;
  619.     
  620.     // Calculate the light levels to use
  621.     //  for each level / distance combination.
  622.     for (i=0 ; i< LIGHTLEVELS ; i++)
  623.     {
  624.     startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
  625.     for (j=0 ; j<MAXLIGHTZ ; j++)
  626.     {
  627. //        scale = FixedDiv ((SCREENWIDTH/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
  628.         scale = FixedDiv (160*FRACUNIT, (j+1)<<LIGHTZSHIFT);
  629.         scale >>= LIGHTSCALESHIFT;
  630.         level = startmap - scale/DISTMAP;
  631.         
  632.         if (level < 0)
  633.         level = 0;
  634.  
  635.         if (level >= NUMCOLORMAPS)
  636.         level = NUMCOLORMAPS-1;
  637.  
  638.         zlight[i][j] = colormaps + level*256;
  639.     }
  640.     }
  641. }
  642.  
  643.  
  644.  
  645. //
  646. // R_SetViewSize
  647. // Do not really change anything here,
  648. //  because it might be in the middle of a refresh.
  649. // The change will take effect next refresh.
  650. //
  651. boolean        setsizeneeded;
  652. int        setblocks;
  653. int        setdetail;
  654.  
  655.  
  656. void
  657. R_SetViewSize
  658. ( int        blocks,
  659.   int        detail )
  660. {
  661.     setsizeneeded = true;
  662.     setblocks = blocks;
  663.     setdetail = detail;
  664. }
  665.  
  666. extern int cpu_type;
  667.  
  668. //
  669. // R_ExecuteSetViewSize
  670. //
  671. void R_ExecuteSetViewSize (void)
  672. {
  673.     fixed_t    cosadj;
  674.     fixed_t    dy;
  675.     int        i;
  676.     int        j;
  677.     int        level;
  678.     int        startmap;     
  679.  
  680.     setsizeneeded = false;
  681.  
  682.     if (setblocks == 11)
  683.     {
  684.     scaledviewwidth = SCREENWIDTH;
  685.     viewheight = SCREENHEIGHT;
  686.     }
  687.     else
  688.     {
  689. //    scaledviewwidth = setblocks*32;
  690. //    viewheight = (setblocks*168/10)&~7;
  691.     scaledviewwidth = (setblocks*SCREENWIDTH/10)&~7;
  692.     viewheight = (setblocks*(SCREENHEIGHT-ST_HEIGHT)/10)&~7;
  693.     }
  694.     
  695.     detailshift = setdetail;
  696.     viewwidth = scaledviewwidth>>detailshift;
  697.     
  698.     centery = viewheight/2;
  699.     centerx = viewwidth/2;
  700.     centerxfrac = centerx<<FRACBITS;
  701.     centeryfrac = centery<<FRACBITS;
  702.     projection = centerxfrac;
  703.  
  704.     if (!detailshift)
  705.     {
  706.     colfunc = basecolfunc = R_DrawColumn;
  707.     fuzzcolfunc = R_DrawFuzzColumn;
  708.     transcolfunc = R_DrawTranslatedColumn;
  709.     spanfunc = R_DrawSpan;
  710.     }
  711.     else
  712.     {
  713.     colfunc = basecolfunc = R_DrawColumnLow;
  714.     fuzzcolfunc = R_DrawFuzzColumnLow;
  715.     transcolfunc = R_DrawTranslatedColumnLow;
  716.     spanfunc = R_DrawSpanLow;
  717.     }
  718.  
  719.     R_InitBuffer (scaledviewwidth, viewheight);
  720.     
  721.     R_InitTextureMapping ();
  722.     
  723.     // psprite scales
  724. //    pspritescale = FRACUNIT*viewwidth/SCREENWIDTH;
  725. //    pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;
  726.     pspritescale = FRACUNIT*viewwidth/320;
  727.     pspriteiscale = FRACUNIT*320/viewwidth;
  728. //    pspritescale2 = FRACUNIT*viewheight/200;
  729.     pspriteiscale2 = FRACUNIT*200/viewheight;
  730.     
  731.     // thing clipping
  732.     for (i=0 ; i<viewwidth ; i++)
  733.     screenheightarray[i] = viewheight;
  734.     
  735.     // planes
  736.     for (i=0 ; i<viewheight ; i++)
  737.     {
  738.     dy = ((i-viewheight/2)<<FRACBITS)+FRACUNIT/2;
  739.     dy = iabs(dy);
  740.     yslope[i] = FixedDiv ( (viewwidth<<detailshift)/2*FRACUNIT, dy);
  741.     }
  742.     
  743.     for (i=0 ; i<viewwidth ; i++)
  744.     {
  745.     cosadj = iabs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
  746.     distscale[i] = FixedDiv (FRACUNIT,cosadj);
  747.     }
  748.     
  749.     // Calculate the light levels to use
  750.     //  for each level / scale combination.
  751.     for (i=0 ; i< LIGHTLEVELS ; i++)
  752.     {
  753.     startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
  754.     for (j=0 ; j<MAXLIGHTSCALE ; j++)
  755.     {
  756.         level = startmap - j*SCREENWIDTH/(viewwidth<<detailshift)/DISTMAP;
  757.         
  758.         if (level < 0)
  759.         level = 0;
  760.  
  761.         if (level >= NUMCOLORMAPS)
  762.         level = NUMCOLORMAPS-1;
  763.  
  764.         scalelight[i][j] = colormaps + level*256;
  765.     }
  766.     }
  767. }
  768.  
  769.  
  770.  
  771. //
  772. // R_Init
  773. //
  774. extern int    detailLevel;
  775. extern int    screenblocks;
  776.  
  777. void R_Init (void)
  778. {
  779.     R_InitData ();
  780.     printf ("\nR_InitData");
  781.     R_InitPointToAngle ();
  782.     printf ("\nR_InitPointToAngle");
  783.     R_InitTables ();
  784.     // viewwidth / viewheight / detailLevel are set by the defaults
  785.     printf ("\nR_InitTables");
  786.  
  787.     R_SetViewSize (screenblocks, detailLevel);
  788.     R_InitPlanes ();
  789.     printf ("\nR_InitPlanes");
  790.     R_InitLightTables ();
  791.     printf ("\nR_InitLightTables");
  792.     R_InitSkyMap ();
  793.     printf ("\nR_InitSkyMap");
  794.     R_InitTranslationTables ();
  795.     printf ("\nR_InitTranslationsTables");
  796.     
  797.     framecount = 0;
  798. }
  799.  
  800.  
  801. //
  802. // R_PointInSubsector
  803. //
  804. subsector_t*
  805. R_PointInSubsector
  806. ( fixed_t    x,
  807.   fixed_t    y )
  808. {
  809.     node_t*    node;
  810.     int        side;
  811.     int        nodenum;
  812.  
  813.     // single subsector is a special case
  814.     if (!numnodes)                
  815.     return subsectors;
  816.         
  817.     nodenum = numnodes-1;
  818.  
  819.     while (! (nodenum & NF_SUBSECTOR) )
  820.     {
  821.     node = &nodes[nodenum];
  822.     side = R_PointOnSide (x, y, node);
  823.     nodenum = node->children[side];
  824.     }
  825.     
  826.     return &subsectors[nodenum & ~NF_SUBSECTOR];
  827. }
  828.  
  829.  
  830.  
  831. //
  832. // R_SetupFrame
  833. //
  834. void R_SetupFrame (player_t* player)
  835. {        
  836.     int        i;
  837.     
  838.     viewplayer = player;
  839.     viewx = player->mo->x;
  840.     viewy = player->mo->y;
  841.     viewangle = player->mo->angle + viewangleoffset;
  842.     extralight = player->extralight;
  843.  
  844.     viewz = player->viewz;
  845.     
  846.     viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
  847.     viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
  848.     
  849.     sscount = 0;
  850.     
  851.     if (player->fixedcolormap)
  852.     {
  853.     fixedcolormap =
  854.         colormaps
  855.         + player->fixedcolormap*256*sizeof(lighttable_t);
  856.     
  857.     walllights = scalelightfixed;
  858.  
  859.     for (i=0 ; i<MAXLIGHTSCALE ; i++)
  860.         scalelightfixed[i] = fixedcolormap;
  861.     }
  862.     else
  863.     fixedcolormap = 0;
  864.         
  865.     framecount++;
  866.     validcount++;
  867. }
  868.  
  869.  
  870. //
  871. // R_RenderView
  872. //
  873. void R_RenderPlayerView (player_t* player)
  874. {    
  875.     R_SetupFrame (player);
  876.  
  877.     // Clear buffers.
  878.     R_ClearClipSegs ();
  879.     R_ClearDrawSegs ();
  880.     R_ClearPlanes ();
  881.     R_ClearSprites ();
  882.     
  883.     // check for new console commands.
  884.     NetUpdate ();
  885.  
  886.     // The head node is the last node output.
  887.     R_RenderBSPNode (numnodes-1);
  888.     
  889.     // Check for new console commands.
  890.     NetUpdate ();
  891.     
  892.     R_DrawPlanes ();
  893.     
  894.     // Check for new console commands.
  895.     NetUpdate ();
  896.     
  897.     R_DrawMasked ();
  898.  
  899.     // Check for new console commands.
  900.     NetUpdate ();                
  901. }
  902.